package com.daily.DailyStudy.线程;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 针对 线程 A B C 各自开始准备，直到三者都准备完毕，然后再同时运行 。也就是要实现一种 线程之间互相等待 的效果，那应该怎么来实现呢？
 * CyclicBarrier 对象，设置 同时等待 的线程数
 * */
public class ABC各自准备准备好了一起执行 {
//    先创建一个公共 CyclicBarrier 对象，设置 同时等待 的线程数，
//    java.util.concurrent.CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
//    这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用 cyclicBarrier.await(); 即可开始等待别人；
//    当指定的 同时等待 的线程数都调用了 cyclicBarrier.await();时，意味着这些线程都准备完毕好，然后这些线程才 同时继续执行

    private static void runABCWhenAllReady(){
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        final Random random = new Random();
        System.out.println(random.nextInt(10000));
        for (char runnerName = 'A' ; runnerName <= 'C' ; runnerName++){
            String rN = String.valueOf(runnerName);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    long prepareTime = random.nextInt(10000)+100;
                    System.out.println( rN + " 开始准备 " + prepareTime);
                    try{
                        Thread.sleep(prepareTime);
                    }catch ( InterruptedException e){
                        e.printStackTrace();
                    }
                    try{
                        System.out.println( rN + " 准备完毕,等待其他线程");
                        cyclicBarrier.await();
                    }catch ( InterruptedException e){
                        e.printStackTrace();
                    }catch ( BrokenBarrierException e){
                        e.printStackTrace();
                    }
                    System.out.println(rN + " 开始运行");
                }
            }).start();
        }
    }

    public static void main(String[] args) {
        runABCWhenAllReady();
    }

}
